package com.duubee.btframe.service;

import com.duubee.btframe.vo.BtCondition;
import com.duubee.btframe.vo.lambda.BtConditionLambda;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

@SuppressWarnings(value = "all")
public interface BtService<T> extends IService<T> {

    /**
     * 通过分页查询
     *
     * @param btPage      分页对象
     * @param btCondition 条件
     * @return 分页结果对象
     */
    IPage<T> queryByPaging(Page btPage, BtCondition btCondition);

    /**
     * 通过id查询单个
     *
     * @param id id
     * @return 实体
     */
    T querySingleById(Serializable id);

    /**
     * 通过条件查询单个
     *
     * @param btCondition 条件构造
     * @return 实体
     */
    T querySingle(BtCondition btCondition);

    /**
     * 通过条件查询单个
     *
     * @param btCondition 条件构造
     * @return 实体
     */
    T querySingleLimit(BtCondition btCondition);

    /**
     * 查询所有数据
     *
     * @return 数据集合
     */
    List<T> queryList();

    /**
     * 通过条件查询数据
     *
     * @param btCondition 条件构造
     * @return 数据集合
     */
    List<T> queryList(BtCondition btCondition);

    /**
     * 保存
     * @param entity 保存对象
     * @return 结果
     */
//    boolean save(T entity);

    /**
     * 插入
     * @param entity 插入对象
     * @return 结果
     */
//    <T> boolean insert(T entity);

    /**
     * 根据 ID 修改
     *
     * @param entity 实体
     * @return 结果
     */
    boolean updateByIdBt(T entity);


    /**
     * 根据 条件 修改
     *
     * @param entity      实体
     * @param btCondition 条件构造器
     * @return 结果
     */
    boolean updateByCondition(T entity, BtCondition btCondition);

    /**
     * 根据 ID 删除
     *
     * @param id 删除的主键key
     * @return 结果
     */
    boolean removeByIdBt(Serializable id);

    /**
     * 根据 条件 删除
     *
     * @param btCondition 删除的条件
     * @return 结果
     */
    boolean removeByCondition(BtCondition btCondition);

    /**
     * 根据 条件 统计
     *
     * @param btCondition 条件构造器
     * @return 统计
     */
    long count(BtCondition btCondition);

    /**
     * 更新或保存(需要在数据表中创建唯一索引  UNIQUE、BTREE)
     *
     * @param entity      实体
     * @param btCondition 条件构造器
     * @return 结果
     */
    boolean saveOrUpdateByUNIQUE(T entity, BtCondition btCondition);

    /**
     * 通过id逻辑删除
     *
     * @param id id
     * @return 结果
     */
    boolean logicRemoveById(Serializable id);

    /**
     * 通过idList逻辑删除
     *
     * @param idList id集合
     * @return 结果
     */
    boolean logicRemoveByIds(Collection<? extends Serializable> idList);


    //--------------------------以下是Lambda方法----------------------------------

    /**
     * 通过分页查询
     *
     * @param btPage            分页对象
     * @param btConditionLambda 条件
     * @return 分页结果对象
     */
    IPage<T> queryByPaging(Page btPage, BtConditionLambda<T> btConditionLambda);

    /**
     * 通过条件查询单个
     *
     * @param btConditionLambda 条件构造
     * @return 实体
     */
    T querySingle(BtConditionLambda<T> btConditionLambda);

    /**
     * 通过条件查询单个
     *
     * @param btConditionLambda 条件构造
     * @return 实体
     */
    T querySingleLimit(BtConditionLambda<T> btConditionLambda);


    /**
     * 通过条件查询数据
     *
     * @param btConditionLambda 条件构造
     * @return 数据集合
     */
    List<T> queryList(BtConditionLambda<T> btConditionLambda);


    /**
     * 根据 条件 修改
     *
     * @param entity            对象
     * @param btConditionLambda 条件构造器
     * @return 结果
     */
    boolean updateByCondition(T entity, BtConditionLambda<T> btConditionLambda);

    /**
     * 根据 条件 删除
     *
     * @param btConditionLambda 删除的条件
     * @return 结果
     */
    boolean removeByCondition(BtConditionLambda<T> btConditionLambda);

    /**
     * 根据 条件 统计
     *
     * @param btConditionLambda 条件构造器
     * @return 数量
     */
    long count(BtConditionLambda<T> btConditionLambda);

    /**
     * 更新或保存(需要在数据表中创建唯一索引  UNIQUE、BTREE)
     *
     * @param btConditionLambda 条件构造器
     * @return 结果
     */
    boolean saveOrUpdateByUNIQUE(T entity, BtConditionLambda<T> btConditionLambda);

}
